package com.zenithmind.common.result;

import lombok.Data;

/**
 * 统一响应结果封装类
 * 遵循单一职责原则：只负责数据封装
 *
 * @param <T> 响应数据类型
 */
@Data
public class Result<T> {
    private Integer code;
    private String msg;
    private T data;

    /**
     * 私有构造方法，防止外部直接实例化
     * 强制使用工厂方法创建实例
     */
    private Result(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    /**
     * 检查结果是否成功
     * @return 如果 code 等于 SUCCESS code 则返回 true，否则 false
     */
    public boolean isSuccess() {
        return ResultCode.SUCCESS.getCode().equals(this.code);
    }

    /**
     * 检查结果是否失败
     * @return 如果 code 不等于 SUCCESS code 则返回 true，否则 false
     */
    public boolean isFailed() {
        return !isSuccess();
    }

    /**
     * 获取状态码
     * @return 状态码
     */
    public Integer getCode() {
        return code;
    }

    /**
     * 获取消息
     * @return 消息
     */
    public String getMsg() {
        return msg;
    }

    /**
     * 获取数据
     * @return 数据
     */
    public T getData() {
        return data;
    }

    /**
     * 设置状态码
     * @param code 状态码
     */
    public void setCode(Integer code) {
        this.code = code;
    }

    /**
     * 设置消息
     * @param msg 消息
     */
    public void setMsg(String msg) {
        this.msg = msg;
    }

    /**
     * 设置数据
     * @param data 数据
     */
    public void setData(T data) {
        this.data = data;
    }

    /**
     * 内部工厂类，负责创建Result实例
     * 遵循单一职责原则：专门负责Result对象的创建
     */
    public static class Builder {

        /**
         * 创建成功结果（无数据）
         */
        public static <T> Result<T> success() {
            return new Result<>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMessage(), null);
        }

        /**
         * 创建成功结果（带数据）
         */
        public static <T> Result<T> success(T data) {
            return new Result<>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMessage(), data);
        }

        /**
         * 创建成功结果（自定义消息和数据）
         */
        public static <T> Result<T> success(String msg, T data) {
            return new Result<>(ResultCode.SUCCESS.getCode(), msg, data);
        }

        /**
         * 创建失败结果（使用ResultCode）
         */
        public static <T> Result<T> fail(ResultCode resultCode) {
            return new Result<>(resultCode.getCode(), resultCode.getMessage(), null);
        }

        /**
         * 创建失败结果（使用ResultCode和自定义消息）
         */
        public static <T> Result<T> fail(ResultCode resultCode, String message) {
            return new Result<>(resultCode.getCode(), message, null);
        }

        /**
         * 创建失败结果（自定义错误码、消息和数据）
         */
        public static <T> Result<T> fail(Integer code, String message, T data) {
            return new Result<>(code, message, data);
        }

        /**
         * 创建失败结果（仅消息）
         */
        public static <T> Result<T> fail(String message) {
            return new Result<>(ResultCode.FAIL.getCode(), message, null);
        }
    }

    // 为了保持向后兼容性，保留静态方法
    public static <T> Result<T> success() {
        return Builder.success();
    }

    public static <T> Result<T> success(T data) {
        return Builder.success(data);
    }

    public static <T> Result<T> success(String msg, T data) {
        return Builder.success(msg, data);
    }

    public static <T> Result<T> fail(ResultCode resultCode) {
        return Builder.fail(resultCode);
    }

    public static <T> Result<T> fail(ResultCode resultCode, String message) {
        return Builder.fail(resultCode, message);
    }

    public static <T> Result<T> fail(Integer code, String errorMessage, T data) {
        return Builder.fail(code, errorMessage, data);
    }

    public static <T> Result<T> fail(String message) {
        return Builder.fail(message);
    }
}
